#include <iostream>
using namespace std;

class Test
{
    private:
        int m_a;
        int m_b;

    public:
        /* 无参数的构造函数 */
        #if 0
        Test()
        {
            m_a = 0;
            m_b = 0;
            std::cout<<"无参数构造函数被调用"<<std::endl;
        }
        #else
        Test() = default;//使用系统默认生成的无参数构造函数
        #endif

        /* 如何解决类型转换构造函数带来的隐式转换风险：explicit:关闭编译器的隐式转换 */
        explicit Test(int a)//类型转换构造函数：构造函数只有一个参数（支持隐式类型转换，存在风险）
        {
            m_a = a;
            m_b = 0;
            std::cout<<"有一个参数的构造函数被调用"<<std::endl;
        }

        operator int()
        {
            return m_a;
        }

        // operator char*()
        // {
        //     return m_b;
        // }

        Test(int a, int b)
        {
            m_a = a;
            m_b = b;
            std::cout<<"有两个参数的构造函数被调用"<<std::endl;
        }
        void printf()
        {
            std::cout<<"a="<<m_a<<",b="<<m_b<<std::endl;
        }         
        ~Test()
        {
            std::cout<<"~Test"<<std::endl;
        } 
};

/* 拷贝构造函数 */



int main()
{
    /* 括号法 */
    #if 1
    // Test t;
    // t.printf();

    // Test t1(1);
    // t1.printf();

    // Test t2(1,4);
    // t2.printf();

    /* 如何将Test类型转换为int,或者char * */
    Test s1(1);
    // int num = s1.operator int();
    int num = static_cast<int>(s1);//s1转成int
    
    // char *ptr = static_cast<char *>(s1);

    #else
    /* 等号法 */
    Test t1 = 10;//初始化：很危险：因为可以将int转换位Test,发生了隐式转换
    t1.printf();
    
    Test t2 = (5);
    t2.printf();
    
    Test t3 = (4,7);//相当于逗号表达式
    t3.printf();

    Test t1 = Test();
    t1.printf();

    Test t2 = Test(8);
    t2.printf();

    Test t3 = Test(1,3);
    t3.printf();
    #endif
    return 0;
}